package com.ruoyi.system.controller;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.StrUtil;
import com.ruoyi.system.domain.Nd_AlarmRecorder;
import com.ruoyi.system.domain.Nd_AntiRunningRecorder;
import com.ruoyi.system.domain.Nd_DeviceAttributeLink;
import com.ruoyi.system.domain.Nd_DevicesWrokStatus;
import com.ruoyi.system.mapper.NdAlarmRecorderMapper;
import com.ruoyi.system.mapper.Nd_ApiMapper;
import com.ruoyi.system.mapper.SysUserMapper;
import com.ruoyi.system.service.INdAlarmRecorderService;
import org.json.JSONArray;
import org.json.JSONObject;
//import com.alibaba.fastjson2.JSONArray;
//import com.alibaba.fastjson2.JSONObject;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 接收设备数据的接口
 */
@Api("接收设备数据的接口")
@RestController
@RequestMapping("/system/api")
public class Nd_ReciverApiController {
    @Autowired
    private Nd_ApiMapper ad_ApiMapper;
    @Resource
    private SysUserMapper sysUserMapper;
    @Autowired
    private INdAlarmRecorderService ndAlarmRecorderService;

    @ApiOperation("接收设备数据api")
    @PostMapping("/msg")
    @Transactional(rollbackFor = Exception.class)
    public String postData(@RequestBody String dataStr, HttpServletRequest request) {
        //全局报警状态
        int alarmStatus = 0;
        // 获取请求来源 IP 地址
        String ip = request.getHeader("X-Forwarded-For");
        if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        System.out.println("请求来源 IP 地址: " + ip);
        // 获取请求来源端口
        int port = request.getRemotePort();
        System.out.println("请求来源端口: " + port);
        //为解析服务的空探测提供返回结果
        System.out.println("dataStr");
        System.out.println(dataStr);
        if (dataStr == null || dataStr.isEmpty() || dataStr.equals("[]")) {
            System.out.println("空请求，解析服务探测");
//            return "{\"msg\": \"ok\",\"code\": \"200\"}";
            return "ok";
        } else {
            Nd_AntiRunningRecorder devAntiRcer = new Nd_AntiRunningRecorder();//防溜记录
            Nd_DevicesWrokStatus devStatus = new Nd_DevicesWrokStatus();//设备状态
            List<Nd_AlarmRecorder> devAlarmRcerArr = new ArrayList();//报警记录集合
            //车站id、站名略码、设备id、设备类型
            JSONArray jsonArray = null;
            try {
                jsonArray = new JSONArray(dataStr);
            } catch (Exception e) {
                System.out.println("dataStr:" + dataStr);
                return "诺斯迪特报错,数据格式有问题";
            }
            JSONObject jsonObj = jsonArray.getJSONObject(0);
            //获取所属车站
            String stationId = ad_ApiMapper.selectStationId(jsonObj.getString("stationCode"));
            if (stationId == null || stationId.isEmpty()) {
                System.out.println("诺斯迪特报错,车站代码" + jsonObj.getString("stationCode") + ",检查台账");
                return "检查车站代码";
            }
            //获取设备ID
            String deviceId = ad_ApiMapper.selectDeviceId(jsonObj.getString("devId"), jsonObj.getString("stationCode"));
            if (deviceId == null || deviceId.isEmpty()) {
                System.out.println("诺斯迪特报错,设备不存在" + jsonObj.getString("devId") + ",检查台账");
                return "设备不存在";
            }


            //设备RFID
            String deviceVIN = jsonObj.getString("devId");
            //获取设备类型  2铁鞋   22铁鞋箱
            String deviceType = jsonObj.getString("devType");
            //站名略码   例如 渡市站 dsz
            String zmlm = jsonObj.getString("stationCode");
            devAntiRcer.Device_Id = deviceId;//防溜记录-设备ID
            devAntiRcer.Station_Id = stationId;//防溜记录-车站ID
            devAntiRcer.zmlm = zmlm;//防溜记录-站名略码

            devStatus.Device_Id = deviceId;//设备状态-设备ID
            devStatus.Station_Id = stationId;//设备状态-车站ID
            devStatus.zmlm = zmlm;//设备状态-站名略码
            devStatus.IsOnLine = "1"; //设备状态-是否在线 在线是1，掉线是2

            if (deviceType.equals("02")) //铁鞋
            {
                devStatus.Device_Type = "2";//设备状态-设备类型 2是铁鞋
                for (int i = 0; i < jsonArray.length(); i++) {
                    //报警记录初始化
                    Nd_AlarmRecorder devAlarmRcer = new Nd_AlarmRecorder();
                    devAlarmRcer.Device_Id = deviceId;
                    devAlarmRcer.Station_Id = stationId;
                    devAlarmRcer.Relieve_Mode = "1"; // 解除模式  1自动  2手动   此处接口除新报警记录，其它都是自动
                    devAlarmRcer.create_by = "系统";
                    devAlarmRcer.create_time = String.valueOf(java.sql.Timestamp.valueOf(java.time.LocalDateTime.now()));
                    devAlarmRcer.update_by = "系统";
                    devAlarmRcer.update_time = String.valueOf(java.sql.Timestamp.valueOf(java.time.LocalDateTime.now()));
                    //报警属性状态初始化
                    Nd_DeviceAttributeLink devAttrLink = new Nd_DeviceAttributeLink();
                    devAttrLink.Device_Id = deviceId;
                    jsonObj = jsonArray.getJSONObject(i);
                    switch (jsonObj.getString("statusType")) {
                        case "0"://设备状态， 0：撤防，1：布防
                            devAntiRcer.Work_Type_Id = (jsonObj.getString("statusValue").equals("1")) ? "1" : "2";  //布防1 撤防2
                            devStatus.Work_Type_Id = devAntiRcer.Work_Type_Id;
                            devStatus.placement_time = LocalDateTime.now().toString();
                            if (devAntiRcer.Work_Type_Id.equals("1")) {
                                devStatus.out_time = null;
                                devStatus.in_time = null;
                                ndAlarmRecorderService.updateAlaerStatus(4, 0
                                        , Integer.parseInt(stationId), devStatus.Device_VIN);
                                ndAlarmRecorderService.updateAlaerStatus(5, 0
                                        , Integer.parseInt(stationId), devStatus.Device_VIN);

                            } else {
                                devStatus.no_box_state="撤防";
                                devStatus.out_time = null;
                                devStatus.in_time = LocalDateTime.now().toString();
                            }
                            ad_ApiMapper.updateInOutTimeStatus2(devStatus);
                            //如果撤防 把布防失效报警解除
                            if (devStatus.Work_Type_Id.equals("2")) {
                                Nd_AlarmRecorder alarm = new Nd_AlarmRecorder();
                                alarm.Device_Id = deviceId;
                                alarm.IS_Relieve = "1";
                                alarm.Relieve_Mode = "1";
                                alarm.update_by = "系统";
                                alarm.Alarm_Type = "2";
                                alarm.update_time = LocalDateTime.now().toString();
                                ad_ApiMapper.updateAlarmRecorder(alarm);
                                Nd_DeviceAttributeLink devAttLink = new Nd_DeviceAttributeLink();
                                devAttLink.Device_Id = deviceId;
                                devAttLink.Attribute_Id = "2"; //报警属性表 2为布防失效
                                devAttLink.Attribute_Value = "1";//更新报警状态  1已解除   2未解除
                                ad_ApiMapper.updateDeviceAttributeLink(devAttLink);
                            }
                            break;
                        case "1"://电池欠压报警   0:正常 ，1:报警
                            //电池欠压               设备接口  0:正常 ,  1:报警
                            //IS_Relieve是否解除     数据表    1:已解除, 2:未解除
                            devAlarmRcer.Alarm_Type = "9";//报警类型  9是电量低
                            devAlarmRcer.IS_Relieve = (jsonObj.getString("statusValue").equals("0")) ? "1" : "2"; //1已解除  2未解除
                            devAttrLink.Attribute_Id = "9"; //报警属性表 9为电量低
                            if (devAlarmRcer.IS_Relieve.equals("1")) {//已解除   更新报警记录 更新报警属性状态
                                ad_ApiMapper.updateAlarmRecorder(devAlarmRcer);//更新之前的报警记录为已解除状态
                                devAttrLink.Attribute_Value = "1";//更新报警状态  1已解除   2未解除
                                ad_ApiMapper.updateDeviceAttributeLink(devAttrLink);
                            } else {
                                alarmStatus = 1;//未解除  表示是新的一条报警信息, 添加报警记录,更新报警属性状态
                                devAlarmRcer.Relieve_Mode = "0";//0表示未确定解除模式
                                devAlarmRcer.Alarm_Time = String.valueOf(java.sql.Timestamp.valueOf(java.time.LocalDateTime.now()));
                                ad_ApiMapper.insertAlarmRecorder(devAlarmRcer);//添加一条新的报警记录
                                devAttrLink.Attribute_Value = "2";// 1已解除 2未解除
                                ad_ApiMapper.updateDeviceAttributeLink(devAttrLink);//更新报警状态
                            }
                            break;
                        case "3"://在线状态  0:掉线，1:上线
                            //在线状态               设备接口  0:掉线 ,  1:在线
                            //IS_Relieve是否解除     数据表    1:已解除, 2:未解除
                            devAlarmRcer.Alarm_Type = "3";//报警类型  3是设备掉线
                            devAlarmRcer.IS_Relieve = (jsonObj.getString("statusValue").equals("0")) ? "2" : "1"; //1已解除  2未解除
                            devAttrLink.Attribute_Id = "3"; //报警属性表 3为设备掉线
                            if (devAlarmRcer.IS_Relieve.equals("1")) {//已解除   更新报警记录 更新报警属性状态
                                ad_ApiMapper.updateAlarmRecorder(devAlarmRcer);//更新之前的报警记录为已解除状态
                                devAttrLink.Attribute_Value = "1";//更新报警状态  1已解除   2未解除
                                ad_ApiMapper.updateDeviceAttributeLink(devAttrLink);
                            } else {
                                alarmStatus = 1;//未解除  表示是新的一条报警信息, 添加报警记录,更新报警属性状态
                                devAlarmRcer.Relieve_Mode = "0";//0表示未确定解除模式
                                devAlarmRcer.Alarm_Time = String.valueOf(java.sql.Timestamp.valueOf(java.time.LocalDateTime.now()));
                                ad_ApiMapper.insertAlarmRecorder(devAlarmRcer);//添加一条新的报警记录
                                devAttrLink.Attribute_Value = "2";// 1已解除 2未解除
                                ad_ApiMapper.updateDeviceAttributeLink(devAttrLink);//更新报警状态
                            }
                            break;
                        case "4"://布防失效  0:正常,1:报警
                            //布防失效               设备接口  0:正常 ,  1:报警
                            //IS_Relieve是否解除     数据表    1:已解除, 2:未解除
                            devAlarmRcer.Alarm_Type = "2";//报警类型  2是布防失效
                            devAlarmRcer.IS_Relieve = (jsonObj.getString("statusValue").equals("0")) ? "1" : "2"; //1已解除  2未解除
                            devAttrLink.Attribute_Id = "2"; //报警属性表 2为布防失效
                            if (devAlarmRcer.IS_Relieve.equals("1")) {//已解除   更新报警记录 更新报警属性状态
                                ad_ApiMapper.updateAlarmRecorder(devAlarmRcer);//更新之前的报警记录为已解除状态
                                devAttrLink.Attribute_Value = "1";//更新报警状态  1已解除   2未解除
                                ad_ApiMapper.updateDeviceAttributeLink(devAttrLink);
                            } else {
                                alarmStatus = 1;//未解除  表示是新的一条报警信息, 添加报警记录,更新报警属性状态
                                devAlarmRcer.Relieve_Mode = "0";//0表示未确定解除模式
                                devAlarmRcer.Alarm_Time = String.valueOf(java.sql.Timestamp.valueOf(java.time.LocalDateTime.now()));
                                ad_ApiMapper.insertAlarmRecorder(devAlarmRcer);//添加一条新的报警记录
                                devAttrLink.Attribute_Value = "2";// 1已解除 2未解除
                                ad_ApiMapper.updateDeviceAttributeLink(devAttrLink);//更新报警状态
                            }
                            break;
                        case "9"://电池电压
                            devStatus.Vbat_Value = jsonObj.getString("statusValue");
                            break;
                    }
                }
                //接下来是防溜记录、防溜状态的处理
                devAntiRcer.Operation_Type_Id = "1";//  1自动  2手动
                devAntiRcer.Person_Id = "0";//自动操做，人员都是0
                devAntiRcer.create_by = "系统";
                devAntiRcer.create_time = String.valueOf(java.sql.Timestamp.valueOf(java.time.LocalDateTime.now()));
                devAntiRcer.update_by = "系统";
                devAntiRcer.update_time = String.valueOf(java.sql.Timestamp.valueOf(java.time.LocalDateTime.now()));
                if (devStatus.Work_Type_Id != null && devStatus.Work_Type_Id.equals("1"))//布防
                {
                    //以确定自动布防 下列信息要初始化，否则前端报错
                    devStatus.Track_Id = "0";
                    devStatus.Postion = "0";
                    devStatus.Railway_CarNo = "";
                    devStatus.SortNo = "0";
                    devStatus.Person_Id = "0";
                    devStatus.Inbox_Id = "0";//布防了的铁鞋 InBoxId(所在铁鞋箱) 应置为0，属于对入箱识别的纠错
                    devAntiRcer.placement_time = LocalDateTime.now().toString();
                    ad_ApiMapper.insertAntiRunningRecorder(devAntiRcer);//添加防溜记录
                } else if (devStatus.Work_Type_Id != null && devStatus.Work_Type_Id.equals("2")) {//撤防
                    //已明确是撤防，下列信息要清空
                    devStatus.Track_Id = "0";
                    devStatus.Postion = "0";
                    devStatus.Railway_CarNo = "";
                    devStatus.SortNo = "0";
                    devStatus.Person_Id = "0";
                    //查出设备的更新前的状态
                    Nd_DevicesWrokStatus prevDevWrokStatus = ad_ApiMapper.selectDeviceStatus_devmsg(devAntiRcer.Device_Id);
                    //查出此设备最后一次的防溜记录
                    Nd_AntiRunningRecorder prevAntiRunningRecorder = ad_ApiMapper.selectAntiRunningRecorder_devmsg(devAntiRcer.Device_Id);
                    devAntiRcer.qbid = prevAntiRunningRecorder.qbid;
                    devAntiRcer.Track_Id = prevDevWrokStatus.Track_Id;
                    devAntiRcer.Postion = prevDevWrokStatus.Postion;
                    devAntiRcer.Railway_CarNo = prevDevWrokStatus.Railway_CarNo;
                    devAntiRcer.SortNo = prevDevWrokStatus.SortNo;
                    ad_ApiMapper.insertAntiRunningRecorder(devAntiRcer);//添加防溜记录
                } else {  //如果既不是布防也不是撤防，维持原来的设备防溜相关信息，可能是心跳包或者报警
                    //查出设备的更新前的状态
                    Nd_DevicesWrokStatus prevDevWrokStatus = ad_ApiMapper.selectDeviceStatus_devmsg(deviceId);
                    //如果既不是布防也不是撤防，维持原来的设备状态
                    devStatus.Track_Id = prevDevWrokStatus.Track_Id;
                    devStatus.Postion = prevDevWrokStatus.Postion;
                    devStatus.Railway_CarNo = prevDevWrokStatus.Railway_CarNo;
                    devStatus.SortNo = prevDevWrokStatus.SortNo;
                    devStatus.Work_Type_Id = prevDevWrokStatus.Work_Type_Id;
                }
                devStatus.Operation_Type_Id = "1"; //   1自动 ,2手动
                devStatus.create_by = "系统";//创建 表示系统
                devStatus.create_time = String.valueOf(java.sql.Timestamp.valueOf(java.time.LocalDateTime.now()));
                devStatus.update_by = "系统";//创建 表示系统
                devStatus.update_time = String.valueOf(java.sql.Timestamp.valueOf(java.time.LocalDateTime.now()));
                devStatus.IsOnLine = "1";// 是否在线  1在线 2掉线
                if (StrUtil.isNotEmpty(devStatus.in_time) || StrUtil.isNotEmpty(devStatus.out_time)) {

                }
//                ad_ApiMapper.
                ad_ApiMapper.updateDeviceStatus_devmsg(devStatus);//更新设备状态
            } else if (deviceType.equals("22")) {//铁鞋箱
                devStatus.Device_Type = "4";//设备状态-设备类型 4是铁鞋铁鞋箱
                devAntiRcer.Person_Id = "0";//自动操做，人员都是0
                devStatus.Person_Id = "0";
                String cardId = jsonObj.getString("cardId");
                if (StrUtil.isNotEmpty(cardId)) {
                    Long userId = sysUserMapper.selectByPhonenumber(cardId);
                    if (userId != null) {
                        devAntiRcer.Person_Id = userId.toString();
                        devStatus.Person_Id = userId.toString();
                    }
                }
                for (int i = 0; i < jsonArray.length(); i++) {
                    //报警记录初始化
                    Nd_AlarmRecorder devAlarmRcer = new Nd_AlarmRecorder();
                    devAlarmRcer.Device_Id = deviceId;
                    devAlarmRcer.Station_Id = stationId;
                    devAlarmRcer.Relieve_Mode = "1"; // 解除模式  1自动  2手动   此处接口除新报警记录，其它都是自动
                    devAlarmRcer.create_by = "系统";
                    devAlarmRcer.create_time = String.valueOf(java.sql.Timestamp.valueOf(java.time.LocalDateTime.now()));
                    devAlarmRcer.update_by = "系统";
                    devAlarmRcer.update_time = String.valueOf(java.sql.Timestamp.valueOf(java.time.LocalDateTime.now()));
                    //用于更新报警属性状态的实例
                    Nd_DeviceAttributeLink devAttrLink = new Nd_DeviceAttributeLink();
                    devAttrLink.Device_Id = deviceId;
                    jsonObj = jsonArray.getJSONObject(i);
                    switch (jsonObj.getString("statusType")) {
                        case "221"://箱门， 0：开箱，1：关箱
                            devStatus.OpenCloseBox = (jsonObj.getString("statusValue").equals("1")) ? "2" : "1";
                            devAntiRcer.Work_Type_Id = (jsonObj.getString("statusValue").equals("1")) ? "4" : "3";
                            if (devStatus.OpenCloseBox.equals("2")) {
                                //如果关箱 把开箱超时报警自动解除
                                Nd_AlarmRecorder alarm = new Nd_AlarmRecorder();
                                alarm.Device_Id = deviceId;
                                alarm.IS_Relieve = "1";
                                alarm.Relieve_Mode = "1";
                                alarm.update_by = "系统";
                                alarm.Alarm_Type = "6";
                                alarm.update_time = LocalDateTime.now().toString();
                                ad_ApiMapper.updateAlarmRecorder(alarm);
                                Nd_DeviceAttributeLink devAttLink = new Nd_DeviceAttributeLink();
                                devAttLink.Device_Id = deviceId;
                                devAttLink.Attribute_Id = "6"; //报警属性表 6为开箱超时
                                devAttLink.Attribute_Value = "1";//更新报警状态  1已解除   2未解除
                                ad_ApiMapper.updateDeviceAttributeLink(devAttLink);
                            }
                            break;
                        case "222"://电池电压
                            devStatus.Vbat_Value = jsonObj.getString("statusValue");
                            break;
                        case "223"://鞋箱温度
                            devStatus.DevTemperature = jsonObj.getString("statusValue");
                            break;
                        case "224"://箱内设备
                            //查询当前箱内设备
                            List<Nd_DevicesWrokStatus> boxDev = ad_ApiMapper.queryInBoxDev(deviceId);
                            //把当前鞋箱清空  后面紧接着会再次识别添加设备
                            ad_ApiMapper.clearBox(deviceId);
                            //读出鞋箱里当前有哪些设备
                            List<Nd_DevicesWrokStatus> devInboxArr1 = new ArrayList<>();
                            ArrayList<Nd_DevicesWrokStatus> inDev = new ArrayList<>();
                            ArrayList<Nd_DevicesWrokStatus> outDev = new ArrayList<>();
                            ArrayList<Nd_DevicesWrokStatus> alarmDev = new ArrayList<>();
                            HashSet<Nd_DevicesWrokStatus> noAlarmDev = new HashSet<>();
                            //把铁鞋逐个解析出来，并更新各个铁鞋的状态  更新电压、电量、所在鞋箱
                            JSONArray devInboxArr2 = jsonObj.getJSONArray("statusValue");
                            if (devInboxArr2.length() == 0) {
                                System.out.println(1);
                                //把箱内设备都添加出箱时间 布防时清楚出箱时间
                                boxDev.stream().forEach(b -> {
                                    b.out_time = LocalDateTime.now().toString();
                                    b.in_time = null;
                                });
                                outDev.addAll(boxDev);
                                noAlarmDev.addAll(boxDev);
                                //更改时间
                                if (outDev != null && !outDev.isEmpty()) {
                                    ad_ApiMapper.updateInOutTimeStatus(outDev);
                                }
                                for (Nd_DevicesWrokStatus nd_devicesWrokStatus1 : noAlarmDev) {
                                    ndAlarmRecorderService.updateAlaerStatus(10, 0
                                            , Integer.parseInt(stationId), nd_devicesWrokStatus1.Device_VIN);
                                }
                                break;
                            }
                            //箱内设备的map
                            Map<String, Nd_DevicesWrokStatus> devStatusMap = boxDev.stream().collect(Collectors.toMap(d -> d.Device_VIN, d -> d));

                            for (int m = 0; m < devInboxArr2.length(); m++) {
                                Nd_DevicesWrokStatus devInbox = new Nd_DevicesWrokStatus();
                                devInbox.zmlm = zmlm;
                                devInbox.Device_VIN = devInboxArr2.getJSONObject(m).getString("devId");
                                devInbox.Inbox_Id = deviceId;
                                devInbox.Vbat_Value = devInboxArr2.getJSONObject(m).getString("batState");
                                devInbox.VbatPercent = devInboxArr2.getJSONObject(m).getString("batLvl");
                                devInbox.InOutBox = "2";//入箱
                                //查出箱内没有的鞋，就是进入的
                                if (!devStatusMap.containsKey(devInbox.Device_VIN)) {
//                                    devInbox.in_time = null;
//                                    devInbox.out_time = LocalDateTime.now().toString();
//                                    outDev.add(devInbox);
                                    devInbox.out_time = null;
                                    devInbox.in_time = null;
                                    inDev.add(devInbox);
                                    //需要解除修改报警信息
                                    System.out.println();
                                    ndAlarmRecorderService.updateAlaerStatus(5, 0
                                            , Integer.parseInt(stationId), devInbox.Device_VIN);
                                    ndAlarmRecorderService.updateAlaerStatus(4, 0
                                            , Integer.parseInt(stationId), devInbox.Device_VIN);

                                     Nd_DevicesWrokStatus device = ad_ApiMapper.getDeviceByDeviceVINAndZmlm(devInbox.Device_VIN, devInbox.zmlm);
                                     if (!deviceId.equals(device.default_box_id.toString())){
                                         alarmDev.add(device);
                                     }else {
                                         noAlarmDev.add(device);
                                     }
                                }
                                devInboxArr1.add(devInbox);

                            }
                            Map<String, Nd_DevicesWrokStatus> serverInMap = devInboxArr1.stream()
                                    .collect(Collectors.toMap(d -> d.Device_VIN, d -> d));
                            for (Map.Entry<String, Nd_DevicesWrokStatus> in : devStatusMap.entrySet()) {
                                //如果新来的在箱内不存在，就是出去的鞋
                                if (!serverInMap.containsKey(in.getKey())) {
                                    in.getValue().in_time = null;
                                    in.getValue().out_time = LocalDateTime.now().toString();
                                    outDev.add(in.getValue());
                                    noAlarmDev.add(in.getValue());
                                }
                            }
                            if (!inDev.isEmpty()) {
                                ad_ApiMapper.updateInOutTimeStatus(inDev);
                            }
                            if (!outDev.isEmpty()) {
                                ad_ApiMapper.updateInOutTimeStatus(outDev);
                            }
                            List<Long> deviceIds = alarmDev.stream().map(d -> Long.parseLong(d.Device_Id)).collect(Collectors.toList());
                            if (!deviceIds.isEmpty()) {
                                alarmStatus = 1;
                                ndAlarmRecorderService.addAlaerStatus(10, deviceIds, Integer.parseInt(stationId));
                                ndAlarmRecorderService.updateAlaerStatusByIds(10, deviceIds);

                            }
                            if (CollectionUtil.isNotEmpty(noAlarmDev)){
                                noAlarmDev.forEach(n->{
                                    ndAlarmRecorderService.updateAlaerStatus(10, 0
                                            , Integer.parseInt(stationId), n.Device_VIN);
                                });
                            }
                            ad_ApiMapper.updateDevicesStatus_devmsg(devInboxArr1);
                            break;
                        case "225"://在线状态  0:掉线，1:上线
                            //在线状态               设备接口  0:掉线 ,  1:在线
                            //IS_Relieve是否解除     数据表    1:已解除, 2:未解除
                            devAlarmRcer.Alarm_Type = "3";//报警类型  3是设备掉线
                            devAlarmRcer.IS_Relieve = (jsonObj.getString("statusValue").equals("0")) ? "2" : "1"; //1已解除  2未解除
                            devAttrLink.Attribute_Id = "3"; //报警属性表 3为设备掉线
                            if (devAlarmRcer.IS_Relieve.equals("1")) {//已解除   更新报警记录 更新报警属性状态
                                ad_ApiMapper.updateAlarmRecorder(devAlarmRcer);//更新之前的报警记录为已解除状态
                                devAttrLink.Attribute_Value = "1";//更新报警状态  1已解除   2未解除
                                ad_ApiMapper.updateDeviceAttributeLink(devAttrLink);
                            } else {                                  //未解除  表示是新的一条报警信息, 添加报警记录,更新报警属性状态
                                alarmStatus = 1;
                                devAlarmRcer.Relieve_Mode = "0";//0表示未确定解除模式
                                devAlarmRcer.Alarm_Time = String.valueOf(java.sql.Timestamp.valueOf(java.time.LocalDateTime.now()));
                                ad_ApiMapper.insertAlarmRecorder(devAlarmRcer);//添加一条新的报警记录
                                devAttrLink.Attribute_Value = "2";// 1已解除 2未解除
                                ad_ApiMapper.updateDeviceAttributeLink(devAttrLink);//更新报警状态
                            }
                            break;
                        case "226"://开箱超时  0:正常,1:报警
                            //开箱超时               设备接口  0:正常 ,  1:报警
                            //IS_Relieve是否解除     数据表    1:已解除, 2:未解除
                            devAlarmRcer.Alarm_Type = "6";//报警类型  6是开箱超时
                            devAlarmRcer.IS_Relieve = (jsonObj.getString("statusValue").equals("0")) ? "1" : "2"; //1已解除  2未解除
                            devAttrLink.Attribute_Id = "6"; //报警属性表 6为开箱超时
                            if (devAlarmRcer.IS_Relieve.equals("1")) {//已解除   更新报警记录 更新报警属性状态
                                ad_ApiMapper.updateAlarmRecorder(devAlarmRcer);//更新之前的报警记录为已解除状态
                                devAttrLink.Attribute_Value = "1";//更新报警状态  1已解除   2未解除
                                ad_ApiMapper.updateDeviceAttributeLink(devAttrLink);
                            } else {                                  //未解除  表示是新的一条报警信息, 添加报警记录,更新报警属性状态
                                alarmStatus = 1;
                                devAlarmRcer.Relieve_Mode = "0";//0表示未确定解除模式
                                devAlarmRcer.Alarm_Time = String.valueOf(java.sql.Timestamp.valueOf(java.time.LocalDateTime.now()));
                                ad_ApiMapper.insertAlarmRecorder(devAlarmRcer);//添加一条新的报警记录
                                devAttrLink.Attribute_Value = "2";// 1已解除 2未解除
                                ad_ApiMapper.updateDeviceAttributeLink(devAttrLink);//更新报警状态
                            }
                            break;
                        case "227"://电池欠压   0:正常 ，1:报警
                            //电池欠压               设备接口  0:正常 ,  1:报警
                            //IS_Relieve是否解除     数据表    1:已解除, 2:未解除
                            devAlarmRcer.Alarm_Type = "9";//报警类型  9是电量低
                            devAlarmRcer.IS_Relieve = (jsonObj.getString("statusValue").equals("0")) ? "1" : "2"; //1已解除  2未解除
                            devAttrLink.Attribute_Id = "9"; //报警属性表 9为电量低
                            if (devAlarmRcer.IS_Relieve.equals("1")) {//已解除   更新报警记录 更新报警属性状态
                                ad_ApiMapper.updateAlarmRecorder(devAlarmRcer);//更新之前的报警记录为已解除状态
                                devAttrLink.Attribute_Value = "1";//更新报警状态  1已解除   2未解除
                                ad_ApiMapper.updateDeviceAttributeLink(devAttrLink);
                            } else {                                  //未解除  表示是新的一条报警信息, 添加报警记录,更新报警属性状态
                                alarmStatus = 1;
                                devAlarmRcer.Relieve_Mode = "0";//0表示未确定解除模式
                                devAlarmRcer.Alarm_Time = String.valueOf(java.sql.Timestamp.valueOf(java.time.LocalDateTime.now()));
                                ad_ApiMapper.insertAlarmRecorder(devAlarmRcer);//添加一条新的报警记录
                                devAttrLink.Attribute_Value = "2";// 1已解除 2未解除
                                ad_ApiMapper.updateDeviceAttributeLink(devAttrLink);//更新报警状态
                            }
                            break;
                        case "228"://高温报警  0:正常,1:报警
                            //高温报警               设备接口  0:正常 ,  1:报警
                            //IS_Relieve是否解除     数据表    1:已解除, 2:未解除
                            devAlarmRcer.Alarm_Type = "8";//报警类型  8是高温报警
                            devAlarmRcer.IS_Relieve = (jsonObj.getString("statusValue").equals("0")) ? "1" : "2"; //1已解除  2未解除
                            devAttrLink.Attribute_Id = "8"; //报警属性表 8为高温报警
                            if (devAlarmRcer.IS_Relieve.equals("1")) {//已解除   更新报警记录 更新报警属性状态
                                ad_ApiMapper.updateAlarmRecorder(devAlarmRcer);//更新之前的报警记录为已解除状态
                                devAttrLink.Attribute_Value = "1";//更新报警状态  1已解除   2未解除
                                ad_ApiMapper.updateDeviceAttributeLink(devAttrLink);
                            } else {                                  //未解除  表示是新的一条报警信息, 添加报警记录,更新报警属性状态
                                alarmStatus = 1;
                                devAlarmRcer.Relieve_Mode = "0";//0表示未确定解除模式
                                devAlarmRcer.Alarm_Time = String.valueOf(java.sql.Timestamp.valueOf(java.time.LocalDateTime.now()));
                                ad_ApiMapper.insertAlarmRecorder(devAlarmRcer);//添加一条新的报警记录
                                devAttrLink.Attribute_Value = "2";// 1已解除 2未解除
                                ad_ApiMapper.updateDeviceAttributeLink(devAttrLink);//更新报警状态
                            }

                            break;
                        case "16"://电量
                            devStatus.VbatPercent = jsonObj.getString("statusValue");
                            break;
                    }
                }
                //接下来是防溜记录
                devAntiRcer.Operation_Type_Id = "1";//  1自动  2手动
                devAntiRcer.create_by = "系统";
                devAntiRcer.create_time = String.valueOf(java.sql.Timestamp.valueOf(java.time.LocalDateTime.now()));
                devAntiRcer.update_by = "系统";
                devAntiRcer.update_time = String.valueOf(java.sql.Timestamp.valueOf(java.time.LocalDateTime.now()));
                ad_ApiMapper.insertAntiRunningRecorder(devAntiRcer);//添加防溜记录
                //设备状态的处理
                devStatus.Operation_Type_Id = "1"; //   1自动 ,2手动
                devStatus.create_by = "系统";//创建 表示系统
                devStatus.create_time = String.valueOf(java.sql.Timestamp.valueOf(java.time.LocalDateTime.now()));
                devStatus.update_by = "系统";//创建 表示系统
                devStatus.update_time = String.valueOf(java.sql.Timestamp.valueOf(java.time.LocalDateTime.now()));
                devStatus.IsOnLine = "1";// 是否在线  1在线 2掉线
                ad_ApiMapper.updateDeviceStatus_devmsg(devStatus);//更新设备状态
            }
            Nd_WebSocketController myWebSocketHandler = new Nd_WebSocketController();
            myWebSocketHandler.sendMessage("devChange");
            if (alarmStatus == 1) {
                myWebSocketHandler.sendMessage("alarmChange");
            }
            return "process over!";
        }
    }

}

